/*
 * XML Type:  BillPayResponseMessageSetV1
 * Namespace: http://ofx.net/types/2003/04
 * Java type: net.ofx.types.x2003.x04.BillPayResponseMessageSetV1
 *
 * Automatically generated - do not modify.
 */
package net.ofx.types.x2003.x04.impl;
/**
 * An XML BillPayResponseMessageSetV1(@http://ofx.net/types/2003/04).
 *
 * This is a complex type.
 */
public class BillPayResponseMessageSetV1Impl extends net.ofx.types.x2003.x04.impl.AbstractResponseMessageSetImpl implements net.ofx.types.x2003.x04.BillPayResponseMessageSetV1
{
    
    public BillPayResponseMessageSetV1Impl(org.apache.xmlbeans.SchemaType sType)
    {
        super(sType);
    }
    
    private static final javax.xml.namespace.QName PAYEETRNRS$0 = 
        new javax.xml.namespace.QName("", "PAYEETRNRS");
    private static final javax.xml.namespace.QName PAYEESYNCRS$2 = 
        new javax.xml.namespace.QName("", "PAYEESYNCRS");
    private static final javax.xml.namespace.QName PMTTRNRS$4 = 
        new javax.xml.namespace.QName("", "PMTTRNRS");
    private static final javax.xml.namespace.QName RECPMTTRNRS$6 = 
        new javax.xml.namespace.QName("", "RECPMTTRNRS");
    private static final javax.xml.namespace.QName PMTINQTRNRS$8 = 
        new javax.xml.namespace.QName("", "PMTINQTRNRS");
    private static final javax.xml.namespace.QName PMTMAILTRNRS$10 = 
        new javax.xml.namespace.QName("", "PMTMAILTRNRS");
    private static final javax.xml.namespace.QName PMTSYNCRS$12 = 
        new javax.xml.namespace.QName("", "PMTSYNCRS");
    private static final javax.xml.namespace.QName RECPMTSYNCRS$14 = 
        new javax.xml.namespace.QName("", "RECPMTSYNCRS");
    private static final javax.xml.namespace.QName PMTMAILSYNCRS$16 = 
        new javax.xml.namespace.QName("", "PMTMAILSYNCRS");
    
    
    /**
     * Gets array of all "PAYEETRNRS" elements
     */
    public net.ofx.types.x2003.x04.PayeeTransactionResponse[] getPAYEETRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PAYEETRNRS$0, targetList);
            net.ofx.types.x2003.x04.PayeeTransactionResponse[] result = new net.ofx.types.x2003.x04.PayeeTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PAYEETRNRS" element
     */
    public net.ofx.types.x2003.x04.PayeeTransactionResponse getPAYEETRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PayeeTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PayeeTransactionResponse)get_store().find_element_user(PAYEETRNRS$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PAYEETRNRS" element
     */
    public int sizeOfPAYEETRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PAYEETRNRS$0);
        }
    }
    
    /**
     * Sets array of all "PAYEETRNRS" element
     */
    public void setPAYEETRNRSArray(net.ofx.types.x2003.x04.PayeeTransactionResponse[] payeetrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(payeetrnrsArray, PAYEETRNRS$0);
        }
    }
    
    /**
     * Sets ith "PAYEETRNRS" element
     */
    public void setPAYEETRNRSArray(int i, net.ofx.types.x2003.x04.PayeeTransactionResponse payeetrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PayeeTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PayeeTransactionResponse)get_store().find_element_user(PAYEETRNRS$0, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(payeetrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PAYEETRNRS" element
     */
    public net.ofx.types.x2003.x04.PayeeTransactionResponse insertNewPAYEETRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PayeeTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PayeeTransactionResponse)get_store().insert_element_user(PAYEETRNRS$0, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PAYEETRNRS" element
     */
    public net.ofx.types.x2003.x04.PayeeTransactionResponse addNewPAYEETRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PayeeTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PayeeTransactionResponse)get_store().add_element_user(PAYEETRNRS$0);
            return target;
        }
    }
    
    /**
     * Removes the ith "PAYEETRNRS" element
     */
    public void removePAYEETRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PAYEETRNRS$0, i);
        }
    }
    
    /**
     * Gets array of all "PAYEESYNCRS" elements
     */
    public net.ofx.types.x2003.x04.PayeeSyncResponse[] getPAYEESYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PAYEESYNCRS$2, targetList);
            net.ofx.types.x2003.x04.PayeeSyncResponse[] result = new net.ofx.types.x2003.x04.PayeeSyncResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PAYEESYNCRS" element
     */
    public net.ofx.types.x2003.x04.PayeeSyncResponse getPAYEESYNCRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PayeeSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PayeeSyncResponse)get_store().find_element_user(PAYEESYNCRS$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PAYEESYNCRS" element
     */
    public int sizeOfPAYEESYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PAYEESYNCRS$2);
        }
    }
    
    /**
     * Sets array of all "PAYEESYNCRS" element
     */
    public void setPAYEESYNCRSArray(net.ofx.types.x2003.x04.PayeeSyncResponse[] payeesyncrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(payeesyncrsArray, PAYEESYNCRS$2);
        }
    }
    
    /**
     * Sets ith "PAYEESYNCRS" element
     */
    public void setPAYEESYNCRSArray(int i, net.ofx.types.x2003.x04.PayeeSyncResponse payeesyncrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PayeeSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PayeeSyncResponse)get_store().find_element_user(PAYEESYNCRS$2, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(payeesyncrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PAYEESYNCRS" element
     */
    public net.ofx.types.x2003.x04.PayeeSyncResponse insertNewPAYEESYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PayeeSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PayeeSyncResponse)get_store().insert_element_user(PAYEESYNCRS$2, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PAYEESYNCRS" element
     */
    public net.ofx.types.x2003.x04.PayeeSyncResponse addNewPAYEESYNCRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PayeeSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PayeeSyncResponse)get_store().add_element_user(PAYEESYNCRS$2);
            return target;
        }
    }
    
    /**
     * Removes the ith "PAYEESYNCRS" element
     */
    public void removePAYEESYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PAYEESYNCRS$2, i);
        }
    }
    
    /**
     * Gets array of all "PMTTRNRS" elements
     */
    public net.ofx.types.x2003.x04.PaymentTransactionResponse[] getPMTTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PMTTRNRS$4, targetList);
            net.ofx.types.x2003.x04.PaymentTransactionResponse[] result = new net.ofx.types.x2003.x04.PaymentTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentTransactionResponse getPMTTRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentTransactionResponse)get_store().find_element_user(PMTTRNRS$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PMTTRNRS" element
     */
    public int sizeOfPMTTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PMTTRNRS$4);
        }
    }
    
    /**
     * Sets array of all "PMTTRNRS" element
     */
    public void setPMTTRNRSArray(net.ofx.types.x2003.x04.PaymentTransactionResponse[] pmttrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(pmttrnrsArray, PMTTRNRS$4);
        }
    }
    
    /**
     * Sets ith "PMTTRNRS" element
     */
    public void setPMTTRNRSArray(int i, net.ofx.types.x2003.x04.PaymentTransactionResponse pmttrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentTransactionResponse)get_store().find_element_user(PMTTRNRS$4, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(pmttrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentTransactionResponse insertNewPMTTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentTransactionResponse)get_store().insert_element_user(PMTTRNRS$4, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentTransactionResponse addNewPMTTRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentTransactionResponse)get_store().add_element_user(PMTTRNRS$4);
            return target;
        }
    }
    
    /**
     * Removes the ith "PMTTRNRS" element
     */
    public void removePMTTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PMTTRNRS$4, i);
        }
    }
    
    /**
     * Gets array of all "RECPMTTRNRS" elements
     */
    public net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse[] getRECPMTTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RECPMTTRNRS$6, targetList);
            net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse[] result = new net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "RECPMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse getRECPMTTRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse)get_store().find_element_user(RECPMTTRNRS$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "RECPMTTRNRS" element
     */
    public int sizeOfRECPMTTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RECPMTTRNRS$6);
        }
    }
    
    /**
     * Sets array of all "RECPMTTRNRS" element
     */
    public void setRECPMTTRNRSArray(net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse[] recpmttrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(recpmttrnrsArray, RECPMTTRNRS$6);
        }
    }
    
    /**
     * Sets ith "RECPMTTRNRS" element
     */
    public void setRECPMTTRNRSArray(int i, net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse recpmttrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse)get_store().find_element_user(RECPMTTRNRS$6, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(recpmttrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "RECPMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse insertNewRECPMTTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse)get_store().insert_element_user(RECPMTTRNRS$6, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "RECPMTTRNRS" element
     */
    public net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse addNewRECPMTTRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringPaymentTransactionResponse)get_store().add_element_user(RECPMTTRNRS$6);
            return target;
        }
    }
    
    /**
     * Removes the ith "RECPMTTRNRS" element
     */
    public void removeRECPMTTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RECPMTTRNRS$6, i);
        }
    }
    
    /**
     * Gets array of all "PMTINQTRNRS" elements
     */
    public net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse[] getPMTINQTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PMTINQTRNRS$8, targetList);
            net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse[] result = new net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PMTINQTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse getPMTINQTRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse)get_store().find_element_user(PMTINQTRNRS$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PMTINQTRNRS" element
     */
    public int sizeOfPMTINQTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PMTINQTRNRS$8);
        }
    }
    
    /**
     * Sets array of all "PMTINQTRNRS" element
     */
    public void setPMTINQTRNRSArray(net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse[] pmtinqtrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(pmtinqtrnrsArray, PMTINQTRNRS$8);
        }
    }
    
    /**
     * Sets ith "PMTINQTRNRS" element
     */
    public void setPMTINQTRNRSArray(int i, net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse pmtinqtrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse)get_store().find_element_user(PMTINQTRNRS$8, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(pmtinqtrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PMTINQTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse insertNewPMTINQTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse)get_store().insert_element_user(PMTINQTRNRS$8, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PMTINQTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse addNewPMTINQTRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentInquiryTransactionResponse)get_store().add_element_user(PMTINQTRNRS$8);
            return target;
        }
    }
    
    /**
     * Removes the ith "PMTINQTRNRS" element
     */
    public void removePMTINQTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PMTINQTRNRS$8, i);
        }
    }
    
    /**
     * Gets array of all "PMTMAILTRNRS" elements
     */
    public net.ofx.types.x2003.x04.PaymentMailTransactionResponse[] getPMTMAILTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PMTMAILTRNRS$10, targetList);
            net.ofx.types.x2003.x04.PaymentMailTransactionResponse[] result = new net.ofx.types.x2003.x04.PaymentMailTransactionResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PMTMAILTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentMailTransactionResponse getPMTMAILTRNRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentMailTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentMailTransactionResponse)get_store().find_element_user(PMTMAILTRNRS$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PMTMAILTRNRS" element
     */
    public int sizeOfPMTMAILTRNRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PMTMAILTRNRS$10);
        }
    }
    
    /**
     * Sets array of all "PMTMAILTRNRS" element
     */
    public void setPMTMAILTRNRSArray(net.ofx.types.x2003.x04.PaymentMailTransactionResponse[] pmtmailtrnrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(pmtmailtrnrsArray, PMTMAILTRNRS$10);
        }
    }
    
    /**
     * Sets ith "PMTMAILTRNRS" element
     */
    public void setPMTMAILTRNRSArray(int i, net.ofx.types.x2003.x04.PaymentMailTransactionResponse pmtmailtrnrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentMailTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentMailTransactionResponse)get_store().find_element_user(PMTMAILTRNRS$10, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(pmtmailtrnrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PMTMAILTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentMailTransactionResponse insertNewPMTMAILTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentMailTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentMailTransactionResponse)get_store().insert_element_user(PMTMAILTRNRS$10, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PMTMAILTRNRS" element
     */
    public net.ofx.types.x2003.x04.PaymentMailTransactionResponse addNewPMTMAILTRNRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentMailTransactionResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentMailTransactionResponse)get_store().add_element_user(PMTMAILTRNRS$10);
            return target;
        }
    }
    
    /**
     * Removes the ith "PMTMAILTRNRS" element
     */
    public void removePMTMAILTRNRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PMTMAILTRNRS$10, i);
        }
    }
    
    /**
     * Gets array of all "PMTSYNCRS" elements
     */
    public net.ofx.types.x2003.x04.PaymentSyncResponse[] getPMTSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PMTSYNCRS$12, targetList);
            net.ofx.types.x2003.x04.PaymentSyncResponse[] result = new net.ofx.types.x2003.x04.PaymentSyncResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PMTSYNCRS" element
     */
    public net.ofx.types.x2003.x04.PaymentSyncResponse getPMTSYNCRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentSyncResponse)get_store().find_element_user(PMTSYNCRS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PMTSYNCRS" element
     */
    public int sizeOfPMTSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PMTSYNCRS$12);
        }
    }
    
    /**
     * Sets array of all "PMTSYNCRS" element
     */
    public void setPMTSYNCRSArray(net.ofx.types.x2003.x04.PaymentSyncResponse[] pmtsyncrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(pmtsyncrsArray, PMTSYNCRS$12);
        }
    }
    
    /**
     * Sets ith "PMTSYNCRS" element
     */
    public void setPMTSYNCRSArray(int i, net.ofx.types.x2003.x04.PaymentSyncResponse pmtsyncrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentSyncResponse)get_store().find_element_user(PMTSYNCRS$12, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(pmtsyncrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PMTSYNCRS" element
     */
    public net.ofx.types.x2003.x04.PaymentSyncResponse insertNewPMTSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentSyncResponse)get_store().insert_element_user(PMTSYNCRS$12, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PMTSYNCRS" element
     */
    public net.ofx.types.x2003.x04.PaymentSyncResponse addNewPMTSYNCRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentSyncResponse)get_store().add_element_user(PMTSYNCRS$12);
            return target;
        }
    }
    
    /**
     * Removes the ith "PMTSYNCRS" element
     */
    public void removePMTSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PMTSYNCRS$12, i);
        }
    }
    
    /**
     * Gets array of all "RECPMTSYNCRS" elements
     */
    public net.ofx.types.x2003.x04.RecurringPaymentSyncResponse[] getRECPMTSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(RECPMTSYNCRS$14, targetList);
            net.ofx.types.x2003.x04.RecurringPaymentSyncResponse[] result = new net.ofx.types.x2003.x04.RecurringPaymentSyncResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "RECPMTSYNCRS" element
     */
    public net.ofx.types.x2003.x04.RecurringPaymentSyncResponse getRECPMTSYNCRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringPaymentSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringPaymentSyncResponse)get_store().find_element_user(RECPMTSYNCRS$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "RECPMTSYNCRS" element
     */
    public int sizeOfRECPMTSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(RECPMTSYNCRS$14);
        }
    }
    
    /**
     * Sets array of all "RECPMTSYNCRS" element
     */
    public void setRECPMTSYNCRSArray(net.ofx.types.x2003.x04.RecurringPaymentSyncResponse[] recpmtsyncrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(recpmtsyncrsArray, RECPMTSYNCRS$14);
        }
    }
    
    /**
     * Sets ith "RECPMTSYNCRS" element
     */
    public void setRECPMTSYNCRSArray(int i, net.ofx.types.x2003.x04.RecurringPaymentSyncResponse recpmtsyncrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringPaymentSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringPaymentSyncResponse)get_store().find_element_user(RECPMTSYNCRS$14, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(recpmtsyncrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "RECPMTSYNCRS" element
     */
    public net.ofx.types.x2003.x04.RecurringPaymentSyncResponse insertNewRECPMTSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringPaymentSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringPaymentSyncResponse)get_store().insert_element_user(RECPMTSYNCRS$14, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "RECPMTSYNCRS" element
     */
    public net.ofx.types.x2003.x04.RecurringPaymentSyncResponse addNewRECPMTSYNCRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.RecurringPaymentSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.RecurringPaymentSyncResponse)get_store().add_element_user(RECPMTSYNCRS$14);
            return target;
        }
    }
    
    /**
     * Removes the ith "RECPMTSYNCRS" element
     */
    public void removeRECPMTSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(RECPMTSYNCRS$14, i);
        }
    }
    
    /**
     * Gets array of all "PMTMAILSYNCRS" elements
     */
    public net.ofx.types.x2003.x04.PaymentMailSyncResponse[] getPMTMAILSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            java.util.List targetList = new java.util.ArrayList();
            get_store().find_all_element_users(PMTMAILSYNCRS$16, targetList);
            net.ofx.types.x2003.x04.PaymentMailSyncResponse[] result = new net.ofx.types.x2003.x04.PaymentMailSyncResponse[targetList.size()];
            targetList.toArray(result);
            return result;
        }
    }
    
    /**
     * Gets ith "PMTMAILSYNCRS" element
     */
    public net.ofx.types.x2003.x04.PaymentMailSyncResponse getPMTMAILSYNCRSArray(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentMailSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentMailSyncResponse)get_store().find_element_user(PMTMAILSYNCRS$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            return target;
        }
    }
    
    /**
     * Returns number of "PMTMAILSYNCRS" element
     */
    public int sizeOfPMTMAILSYNCRSArray()
    {
        synchronized (monitor())
        {
            check_orphaned();
            return get_store().count_elements(PMTMAILSYNCRS$16);
        }
    }
    
    /**
     * Sets array of all "PMTMAILSYNCRS" element
     */
    public void setPMTMAILSYNCRSArray(net.ofx.types.x2003.x04.PaymentMailSyncResponse[] pmtmailsyncrsArray)
    {
        synchronized (monitor())
        {
            check_orphaned();
            arraySetterHelper(pmtmailsyncrsArray, PMTMAILSYNCRS$16);
        }
    }
    
    /**
     * Sets ith "PMTMAILSYNCRS" element
     */
    public void setPMTMAILSYNCRSArray(int i, net.ofx.types.x2003.x04.PaymentMailSyncResponse pmtmailsyncrs)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentMailSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentMailSyncResponse)get_store().find_element_user(PMTMAILSYNCRS$16, i);
            if (target == null)
            {
                throw new IndexOutOfBoundsException();
            }
            target.set(pmtmailsyncrs);
        }
    }
    
    /**
     * Inserts and returns a new empty value (as xml) as the ith "PMTMAILSYNCRS" element
     */
    public net.ofx.types.x2003.x04.PaymentMailSyncResponse insertNewPMTMAILSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentMailSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentMailSyncResponse)get_store().insert_element_user(PMTMAILSYNCRS$16, i);
            return target;
        }
    }
    
    /**
     * Appends and returns a new empty value (as xml) as the last "PMTMAILSYNCRS" element
     */
    public net.ofx.types.x2003.x04.PaymentMailSyncResponse addNewPMTMAILSYNCRS()
    {
        synchronized (monitor())
        {
            check_orphaned();
            net.ofx.types.x2003.x04.PaymentMailSyncResponse target = null;
            target = (net.ofx.types.x2003.x04.PaymentMailSyncResponse)get_store().add_element_user(PMTMAILSYNCRS$16);
            return target;
        }
    }
    
    /**
     * Removes the ith "PMTMAILSYNCRS" element
     */
    public void removePMTMAILSYNCRS(int i)
    {
        synchronized (monitor())
        {
            check_orphaned();
            get_store().remove_element(PMTMAILSYNCRS$16, i);
        }
    }
}
